home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2002 #4 / K-CD-4-2002.ISO / Empire Earth / EEDemo.exe / Disk1 / Random Map Scripts / Continental / Continental Large.rmv < prev    next >
Encoding:
Text File  |  2001-09-27  |  50.3 KB  |  1,574 lines

  1. //////////////////////////////////////////////////////////////////////
  2. //
  3. // Continental Large.rmv
  4. //
  5. //
  6. // Copyright (c) 2000, Stainless Steel Studios, Inc. All rights reserved.
  7. // PROPRIETARY and CONFIDENTIAL.
  8. //
  9. // $Creator: Richard Bishop $
  10. // 
  11. //////////////////////////////////////////////////////////////////////
  12.  
  13. ResourceSeperation    5
  14.  
  15. #if            NOTDEFINED(CONTINENTAL_LARGE_RMV)
  16. #define        (CONTINENTAL_LARGE_RMV,1)
  17.  
  18. //////////////////////////////////////////////////////////////////////
  19. // Definitions we are required to define for continental maps
  20. //////////////////////////////////////////////////////////////////////
  21.  
  22. //////////////////////////////////////////////////////////////////////
  23. // Secondary Resource Placements
  24.  
  25. #if DEFINED(kWinterMap)
  26.   PlaceWorldUnitInRing (Res-Walrus, 12, 12)
  27.   PlaceWorldUnitInRing (Res-Walrus, 12, 12)
  28. #else 
  29.   PlaceWorldUnitInRing (Res-Hippopotamus, 12, 12)
  30.   PlaceWorldUnitInRing (Res-Hippopotamus, 12, 12)
  31. #endif
  32.  
  33. PlaceResourceInRing (Gold, 14, 16)
  34. PlaceResourceInRing (Iron, 15, 17)
  35.  
  36. //////////////////////////////////////////////////////////////////////
  37. // Resource Limitations
  38. ResourcePlacementLimit (Gold,         8,    9)
  39. ResourcePlacementLimit (Steel,         7,     8)
  40. ResourcePlacementLimit (Berry,         6,    7)
  41. ResourcePlacementLimit (Tree,         3,    5)
  42. ResourcePlacementLimit (Stone,         11,    12)
  43.  
  44. #if Is2Players
  45. //////////////////////////////////////////////////////////////////////
  46. // 2 PLAYERS...
  47. //////////////////////////////////////////////////////////////////////
  48.  
  49. PlaceResourceInRing (Gold, 60, 65)
  50.  
  51. PlaceResourceInRing (Iron, 60, 65)
  52. PlaceResourceInRing (Berry, 28, 34)
  53. PlaceResourceInRing (Berry, 60, 65)
  54. PlaceResourceInRing (Stone, 60, 65)
  55.  
  56. //////////////////////////////////////////////////////////////////////
  57. // terrain definitions
  58. HeightMapSmoothness                    0)
  59. #define        (kMinIntElevation,            -8)
  60. #define        (kMaxIntElevation,            8)
  61. #define        (kElevationScale,                0.5)
  62. #define        (kPercentLand,                Between(.71, .71))
  63. #define        (kWaterBorder,                14)
  64. #define        (kHeightMapChaos,                Between(15, 15))
  65.                                             
  66. #define        (kMinimumStartPositionToMapEdge        1)
  67. #define        (kOuterPushFromMapCenter        28)
  68. #define        (kInnerPushFromMapCenter         0)
  69.  
  70. //////////////////////////////////////////////////////////////////////
  71. // player definitions
  72. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  73. #define        (kPlayerInnerRadius,            0.7)
  74. #define        (kPlayerOuterRadius,            0.85)
  75. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  76. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  77. #define        (kPlayerLandChaos,            0.8)
  78. #define        (kPlayerLandClumps,            1)
  79. #define        (kPlayerFlatChaos,            0.8)
  80. #define        (kPlayerFlatClumps,            2)
  81. #define        (kPlayerTreePercentage,            0.05)
  82.  
  83.  
  84. //////////////////////////////////////////////////////////////////////
  85. // inner neutral definitions
  86. #define        (kNeutralInnerRadius,            0.05)
  87. #define        (kNeutralOuterRadius,            0.55)
  88. #define        (kNeutralOptimalFactor,            0.7)
  89. #define        (kNumInnerNeutrals,            Between(25, 25))
  90. #define        (kInnerNeutralPercentLand,        0.3)
  91. #define        (kInnerNeutralPercentFlat,        0.5)
  92. #define        (kInnerNeutralTreePercentage,          0.1)
  93. #define        (kInnerNeutralLandChaos,        0.9)
  94. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  95. #define        (kInnerNeutralFlatChaos,        0.8)
  96. #define        (kInnerNeutralFlatClumps,        1)
  97.  
  98.  
  99. //////////////////////////////////////////////////////////////////////
  100. // outer neutral definitions
  101. #define        (kNumOuterNeutrals,            15)
  102. #define        (kOuterNeutralPercentLand,        0.45)
  103. #define        (kOuterNeutralPercentFlat,        0.5)
  104. #define        (kOuterNeutralTreePercentage,          0.1)
  105. #define        (kOuterNeutralLandChaos,        0.8)
  106. #define        (kOuterNeutralLandClumps,        2)
  107. #define        (kOuterNeutralFlatChaos,        0.8)
  108. #define        (kOuterNeutralFlatClumps,        1)
  109.  
  110.  
  111. //////////////////////////////////////////////////////////////////////
  112. // resource definitions
  113. #define        (kMaxResourceElevation,            2)
  114. #define        (kResourceToEdgeDistance,        1)
  115. #define        (kResourceToWaterDistance,        1)
  116.  
  117. #define        (kAnimalPerPlayer,            0)
  118. #define        (kAnimalPerNeutral,            0)
  119.  
  120. #if (IsPaleoEpoch) 
  121.   #define  (kBerryPerPlayer,    2)
  122. #else
  123.   #define  (kBerryPerPlayer,    1)
  124. #endif
  125.  
  126. #define        (kBerryPerNeutral,                0)
  127.  
  128. #define        (kFishPerPlayer,                5)
  129. #define        (kFishPerNeutral,                60)
  130.  
  131. #define        (kGoldPerPlayer,                1)
  132. #define        (kGoldPerNeutral,                4)
  133.  
  134. #define        (kOilPerPlayer,                    0)
  135. #define        (kOilPerNeutral,                0)
  136.  
  137. #define        (kSteelPerPlayer,                1)
  138. #define        (kSteelPerNeutral,                4)
  139.  
  140. #define        (kStonePerPlayer,                1)
  141. #define        (kStonePerNeutral,                1)
  142.  
  143. #define        (kTreePerPlayer,                between(2,3))
  144. #define        (kTreePerNeutral,                0)
  145.  
  146.  
  147. //////////////////////////////////////////////////////////////////////
  148. // forest definitions
  149. #define        (kForestFreeRadius,            7.0)
  150. #define        (kForestsPerPlayer,            1)
  151. #define        (kForestChaosLevel,            0.1)
  152. #define        (kMaxClumpsPerForest,              2)
  153.  
  154.  
  155. #elif Is3Players
  156. //////////////////////////////////////////////////////////////////////
  157. // 3 PLAYERS...
  158. //////////////////////////////////////////////////////////////////////
  159.  
  160. PlaceResourceInRing (Gold, 50, 55)
  161. PlaceResourceInRing (Iron, 50, 55)
  162. PlaceResourceInRing (Berry, 40, 48)
  163.  
  164. //////////////////////////////////////////////////////////////////////
  165. // terrain definitions
  166. HeightMapSmoothness                    0)
  167. #define        (kMinIntElevation,            -8)
  168. #define        (kMaxIntElevation,            8)
  169. #define        (kElevationScale,                0.5)
  170. #define        (kPercentLand,                Between(.71, .71))
  171. #define        (kWaterBorder,                14)
  172. #define        (kHeightMapChaos,                Between(15, 15))
  173.                                             
  174. #define        (kMinimumStartPositionToMapEdge        1)
  175. #define        (kOuterPushFromMapCenter        28)
  176. #define        (kInnerPushFromMapCenter         0)
  177.  
  178. //////////////////////////////////////////////////////////////////////
  179. // player definitions
  180. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  181. #define        (kPlayerInnerRadius,            0.7)
  182. #define        (kPlayerOuterRadius,            0.85)
  183. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  184. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  185. #define        (kPlayerLandChaos,            0.8)
  186. #define        (kPlayerLandClumps,            1)
  187. #define        (kPlayerFlatChaos,            0.8)
  188. #define        (kPlayerFlatClumps,            2)
  189. #define        (kPlayerTreePercentage,            0.05)
  190.  
  191.  
  192. //////////////////////////////////////////////////////////////////////
  193. // inner neutral definitions
  194. #define        (kNeutralInnerRadius,            0.05)
  195. #define        (kNeutralOuterRadius,            0.55)
  196. #define        (kNeutralOptimalFactor,            0.7)
  197. #define        (kNumInnerNeutrals,            Between(25, 25))
  198. #define        (kInnerNeutralPercentLand,        0.3)
  199. #define        (kInnerNeutralPercentFlat,        0.5)
  200. #define        (kInnerNeutralTreePercentage,          0.1)
  201. #define        (kInnerNeutralLandChaos,        0.9)
  202. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  203. #define        (kInnerNeutralFlatChaos,        0.8)
  204. #define        (kInnerNeutralFlatClumps,        1)
  205.  
  206.  
  207. //////////////////////////////////////////////////////////////////////
  208. // outer neutral definitions
  209. #define        (kNumOuterNeutrals,            15)
  210. #define        (kOuterNeutralPercentLand,        0.35)
  211. #define        (kOuterNeutralPercentFlat,        0.35)
  212. #define        (kOuterNeutralTreePercentage,          0.1)
  213. #define        (kOuterNeutralLandChaos,        0.8)
  214. #define        (kOuterNeutralLandClumps,        2)
  215. #define        (kOuterNeutralFlatChaos,        0.8)
  216. #define        (kOuterNeutralFlatClumps,        1)
  217.  
  218.  
  219. //////////////////////////////////////////////////////////////////////
  220. // resource definitions
  221. #define        (kMaxResourceElevation,            2)
  222. #define        (kResourceToEdgeDistance,        1)
  223. #define        (kResourceToWaterDistance,        1)
  224.  
  225. #define        (kAnimalPerPlayer,            0)
  226. #define        (kAnimalPerNeutral,            0)
  227.  
  228. #if (IsPaleoEpoch) 
  229.   #define  (kBerryPerPlayer,    2)
  230. #else
  231.   #define  (kBerryPerPlayer,    1)
  232. #endif
  233.  
  234. #define        (kBerryPerNeutral,                0)
  235.  
  236. #define        (kFishPerPlayer,                5)
  237. #define        (kFishPerNeutral,                60)
  238.  
  239. #define        (kGoldPerPlayer,                1)
  240. #define        (kGoldPerNeutral,                5)
  241.  
  242. #define        (kOilPerPlayer,                    0)
  243. #define        (kOilPerNeutral,                0)
  244.  
  245. #define        (kSteelPerPlayer,                1)
  246. #define        (kSteelPerNeutral,                5)
  247.  
  248. #define        (kStonePerPlayer,                1)
  249. #define        (kStonePerNeutral,                4)
  250.  
  251. #define        (kTreePerPlayer,                between(2,3))
  252. #define        (kTreePerNeutral,                0)
  253.  
  254.  
  255. //////////////////////////////////////////////////////////////////////
  256. // forest definitions
  257. #define        (kForestFreeRadius,            7.0)
  258. #define        (kForestsPerPlayer,            1)
  259. #define        (kForestChaosLevel,            0.1)
  260. #define        (kMaxClumpsPerForest,              2)
  261.  
  262. #elif Is4Players
  263. //////////////////////////////////////////////////////////////////////
  264. // 4 PLAYERS...
  265. //////////////////////////////////////////////////////////////////////
  266.  
  267. PlaceResourceInRing (Gold, 45, 50)
  268. PlaceResourceInRing (Iron, 45, 50)
  269. PlaceResourceInRing (Berry, 40, 48)
  270.  
  271. //////////////////////////////////////////////////////////////////////
  272. // terrain definitions
  273. HeightMapSmoothness                    0)
  274. #define        (kMinIntElevation,            -8)
  275. #define        (kMaxIntElevation,            8)
  276. #define        (kElevationScale,                0.5)
  277. #define        (kPercentLand,                Between(.71, .71))
  278. #define        (kWaterBorder,                10)
  279. #define        (kHeightMapChaos,                Between(15, 15))
  280.                                             
  281. #define        (kMinimumStartPositionToMapEdge        1)
  282. #define        (kOuterPushFromMapCenter        28)
  283. #define        (kInnerPushFromMapCenter         0)
  284.  
  285. //////////////////////////////////////////////////////////////////////
  286. // player definitions
  287. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  288. #define        (kPlayerInnerRadius,            0.7)
  289. #define        (kPlayerOuterRadius,            0.85)
  290. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  291. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  292. #define        (kPlayerLandChaos,            0.8)
  293. #define        (kPlayerLandClumps,            1)
  294. #define        (kPlayerFlatChaos,            0.8)
  295. #define        (kPlayerFlatClumps,            2)
  296. #define        (kPlayerTreePercentage,            0.05)
  297.  
  298.  
  299. //////////////////////////////////////////////////////////////////////
  300. // inner neutral definitions
  301. #define        (kNeutralInnerRadius,            0.05)
  302. #define        (kNeutralOuterRadius,            0.55)
  303. #define        (kNeutralOptimalFactor,            0.7)
  304. #define        (kNumInnerNeutrals,            Between(25, 25))
  305. #define        (kInnerNeutralPercentLand,        0.3)
  306. #define        (kInnerNeutralPercentFlat,        0.5)
  307. #define        (kInnerNeutralTreePercentage,          0.1)
  308. #define        (kInnerNeutralLandChaos,        0.9)
  309. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  310. #define        (kInnerNeutralFlatChaos,        0.8)
  311. #define        (kInnerNeutralFlatClumps,        1)
  312.  
  313.  
  314. //////////////////////////////////////////////////////////////////////
  315. // outer neutral definitions
  316. #define        (kNumOuterNeutrals,            15)
  317. #define        (kOuterNeutralPercentLand,        0.35)
  318. #define        (kOuterNeutralPercentFlat,        0.35)
  319. #define        (kOuterNeutralTreePercentage,          0.1)
  320. #define        (kOuterNeutralLandChaos,        0.8)
  321. #define        (kOuterNeutralLandClumps,        2)
  322. #define        (kOuterNeutralFlatChaos,        0.8)
  323. #define        (kOuterNeutralFlatClumps,        1)
  324.  
  325. //////////////////////////////////////////////////////////////////////
  326. // resource definitions
  327. #define        (kMaxResourceElevation,            2)
  328. #define        (kResourceToEdgeDistance,        1)
  329. #define        (kResourceToWaterDistance,        1)
  330.  
  331. #define        (kAnimalPerPlayer,            0)
  332. #define        (kAnimalPerNeutral,            0)
  333.  
  334. #if (IsPaleoEpoch) 
  335.   #define  (kBerryPerPlayer,    2)
  336. #else
  337.   #define  (kBerryPerPlayer,    1)
  338. #endif
  339.  
  340. #define        (kBerryPerNeutral,                0)
  341.  
  342. #define        (kFishPerPlayer,                5)
  343. #define        (kFishPerNeutral,                60)
  344.  
  345. #define        (kGoldPerPlayer,                1)
  346. #define        (kGoldPerNeutral,                6)
  347.  
  348. #define        (kOilPerPlayer,                    0)
  349. #define        (kOilPerNeutral,                0)
  350.  
  351. #define        (kSteelPerPlayer,                1)
  352. #define        (kSteelPerNeutral,                6)
  353.  
  354. #define        (kStonePerPlayer,                1)
  355. #define        (kStonePerNeutral,                5)
  356.  
  357. #define        (kTreePerPlayer,                between(2,3))
  358. #define        (kTreePerNeutral,                0)
  359.  
  360. //////////////////////////////////////////////////////////////////////
  361. // forest definitions
  362. #define        (kForestFreeRadius,            7.0)
  363. #define        (kForestsPerPlayer,            1)
  364. #define        (kForestChaosLevel,            0.1)
  365. #define        (kMaxClumpsPerForest,              2)
  366.  
  367. #elif Is5Players
  368. //////////////////////////////////////////////////////////////////////
  369. // 5 PLAYERS...
  370. //////////////////////////////////////////////////////////////////////
  371.  
  372. PlaceResourceInRing (Berry, 40, 48)
  373. PlaceResourceInRing (Gold, 45, 50)
  374. PlaceResourceInRing (Iron, 45, 50)
  375.  
  376. //////////////////////////////////////////////////////////////////////
  377. // terrain definitions
  378. HeightMapSmoothness                    0)
  379. #define        (kMinIntElevation,            -8)
  380. #define        (kMaxIntElevation,            8)
  381. #define        (kElevationScale,                0.5)
  382. #define        (kPercentLand,                Between(.71, .71))
  383. #define        (kWaterBorder,                10)
  384. #define        (kHeightMapChaos,                Between(15, 15))
  385.                                             
  386. #define        (kMinimumStartPositionToMapEdge        1)
  387. #define        (kOuterPushFromMapCenter        28)
  388. #define        (kInnerPushFromMapCenter         0)
  389.  
  390. //////////////////////////////////////////////////////////////////////
  391. // player definitions
  392. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  393. #define        (kPlayerInnerRadius,            0.7)
  394. #define        (kPlayerOuterRadius,            0.85)
  395. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  396. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  397. #define        (kPlayerLandChaos,            0.8)
  398. #define        (kPlayerLandClumps,            1)
  399. #define        (kPlayerFlatChaos,            0.8)
  400. #define        (kPlayerFlatClumps,            2)
  401. #define        (kPlayerTreePercentage,            0.05)
  402.  
  403.  
  404. //////////////////////////////////////////////////////////////////////
  405. // inner neutral definitions
  406. #define        (kNeutralInnerRadius,            0.05)
  407. #define        (kNeutralOuterRadius,            0.55)
  408. #define        (kNeutralOptimalFactor,            0.7)
  409. #define        (kNumInnerNeutrals,            Between(25, 25))
  410. #define        (kInnerNeutralPercentLand,        0.33)
  411. #define        (kInnerNeutralPercentFlat,        0.5)
  412. #define        (kInnerNeutralTreePercentage,          0.1)
  413. #define        (kInnerNeutralLandChaos,        0.9)
  414. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  415. #define        (kInnerNeutralFlatChaos,        0.8)
  416. #define        (kInnerNeutralFlatClumps,        1)
  417.  
  418.  
  419. //////////////////////////////////////////////////////////////////////
  420. // outer neutral definitions
  421. #define        (kNumOuterNeutrals,            15)
  422. #define        (kOuterNeutralPercentLand,        0.35)
  423. #define        (kOuterNeutralPercentFlat,        0.35)
  424. #define        (kOuterNeutralTreePercentage,          0.1)
  425. #define        (kOuterNeutralLandChaos,        0.8)
  426. #define        (kOuterNeutralLandClumps,        2)
  427. #define        (kOuterNeutralFlatChaos,        0.8)
  428. #define        (kOuterNeutralFlatClumps,        1)
  429.  
  430.  
  431. //////////////////////////////////////////////////////////////////////
  432. // resource definitions
  433. #define        (kMaxResourceElevation,            2)
  434. #define        (kResourceToEdgeDistance,        1)
  435. #define        (kResourceToWaterDistance,        1)
  436.  
  437. #define        (kAnimalPerPlayer,            0)
  438. #define        (kAnimalPerNeutral,            0)
  439.  
  440. #if (IsPaleoEpoch) 
  441.   #define  (kBerryPerPlayer,    2)
  442. #else
  443.   #define  (kBerryPerPlayer,    1)
  444. #endif
  445.  
  446. #define        (kBerryPerNeutral,                0)
  447.  
  448. #define        (kFishPerPlayer,                5)
  449. #define        (kFishPerNeutral,                60)
  450.  
  451. #define        (kGoldPerPlayer,                1)
  452. #define        (kGoldPerNeutral,                7)
  453.  
  454. #define        (kOilPerPlayer,                    0)
  455. #define        (kOilPerNeutral,                0)
  456.  
  457. #define        (kSteelPerPlayer,                1)
  458. #define        (kSteelPerNeutral,                7)
  459.  
  460. #define        (kStonePerPlayer,                1)
  461. #define        (kStonePerNeutral,                5)
  462.  
  463. #define        (kTreePerPlayer,                between(2,3))
  464. #define        (kTreePerNeutral,                0)
  465.  
  466.  
  467. //////////////////////////////////////////////////////////////////////
  468. // forest definitions
  469. #define        (kForestFreeRadius,            7.0)
  470. #define        (kForestsPerPlayer,            1)
  471. #define        (kForestChaosLevel,            0.1)
  472. #define        (kMaxClumpsPerForest,              2)
  473.  
  474. #elif Is6Players
  475. //////////////////////////////////////////////////////////////////////
  476. // 6 PLAYERS...
  477. //////////////////////////////////////////////////////////////////////
  478.  
  479. PlaceResourceInRing (Gold, 26, 27)
  480. PlaceResourceInRing (Iron, 26, 27)
  481. PlaceResourceInRing (Berry, 40, 48)
  482.  
  483. //////////////////////////////////////////////////////////////////////
  484. // terrain definitions
  485. HeightMapSmoothness                    0)
  486. #define        (kMinIntElevation,            -8)
  487. #define        (kMaxIntElevation,            8)
  488. #define        (kElevationScale,                0.5)
  489. #define        (kPercentLand,                Between(.71, .71))
  490. #define        (kWaterBorder,                10)
  491. #define        (kHeightMapChaos,                Between(15, 15))
  492.                                             
  493. #define        (kMinimumStartPositionToMapEdge        1)
  494. #define        (kOuterPushFromMapCenter        28)
  495. #define        (kInnerPushFromMapCenter         0)
  496.  
  497. //////////////////////////////////////////////////////////////////////
  498. // player definitions
  499. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  500. #define        (kPlayerInnerRadius,            0.7)
  501. #define        (kPlayerOuterRadius,            0.85)
  502. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  503. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  504. #define        (kPlayerLandChaos,            0.8)
  505. #define        (kPlayerLandClumps,            1)
  506. #define        (kPlayerFlatChaos,            0.8)
  507. #define        (kPlayerFlatClumps,            2)
  508. #define        (kPlayerTreePercentage,            0.05)
  509.  
  510.  
  511. //////////////////////////////////////////////////////////////////////
  512. // inner neutral definitions
  513. #define        (kNeutralInnerRadius,            0.05)
  514. #define        (kNeutralOuterRadius,            0.55)
  515. #define        (kNeutralOptimalFactor,            0.7)
  516. #define        (kNumInnerNeutrals,            Between(25, 25))
  517. #define        (kInnerNeutralPercentLand,        0.33)
  518. #define        (kInnerNeutralPercentFlat,        0.5)
  519. #define        (kInnerNeutralTreePercentage,          0.1)
  520. #define        (kInnerNeutralLandChaos,        0.9)
  521. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  522. #define        (kInnerNeutralFlatChaos,        0.8)
  523. #define        (kInnerNeutralFlatClumps,        1)
  524.  
  525.  
  526. //////////////////////////////////////////////////////////////////////
  527. // outer neutral definitions
  528. #define        (kNumOuterNeutrals,            15)
  529. #define        (kOuterNeutralPercentLand,        0.35)
  530. #define        (kOuterNeutralPercentFlat,        0.35)
  531. #define        (kOuterNeutralTreePercentage,          0.1)
  532. #define        (kOuterNeutralLandChaos,        0.8)
  533. #define        (kOuterNeutralLandClumps,        2)
  534. #define        (kOuterNeutralFlatChaos,        0.8)
  535. #define        (kOuterNeutralFlatClumps,        1)
  536.  
  537.  
  538. //////////////////////////////////////////////////////////////////////
  539. // resource definitions
  540. #define        (kMaxResourceElevation,            2)
  541. #define        (kResourceToEdgeDistance,        1)
  542. #define        (kResourceToWaterDistance,        1)
  543.  
  544. #define        (kAnimalPerPlayer,            0)
  545. #define        (kAnimalPerNeutral,            0)
  546.  
  547. #if (IsPaleoEpoch) 
  548.   #define  (kBerryPerPlayer,    2)
  549. #else
  550.   #define  (kBerryPerPlayer,    1)
  551. #endif
  552.  
  553. #define        (kBerryPerNeutral,                0)
  554.  
  555. #define        (kFishPerPlayer,                5)
  556. #define        (kFishPerNeutral,                60)
  557.  
  558. #define        (kGoldPerPlayer,                1)
  559. #define        (kGoldPerNeutral,                8)
  560.  
  561. #define        (kOilPerPlayer,                    0)
  562. #define        (kOilPerNeutral,                0)
  563.  
  564. #define        (kSteelPerPlayer,                1)
  565. #define        (kSteelPerNeutral,                8)
  566.  
  567. #define        (kStonePerPlayer,                1)
  568. #define        (kStonePerNeutral,                6)
  569.  
  570. #define        (kTreePerPlayer,                between(2,3))
  571. #define        (kTreePerNeutral,                0)
  572.  
  573.  
  574. //////////////////////////////////////////////////////////////////////
  575. // forest definitions
  576. #define        (kForestFreeRadius,            7.0)
  577. #define        (kForestsPerPlayer,            1)
  578. #define        (kForestChaosLevel,            0.1)
  579. #define        (kMaxClumpsPerForest,              2)
  580.  
  581. #elif Is7Players
  582. //////////////////////////////////////////////////////////////////////
  583. // 7 PLAYERS...
  584. //////////////////////////////////////////////////////////////////////
  585.  
  586. PlaceResourceInRing (Gold, 26, 27)
  587. PlaceResourceInRing (Iron, 26, 27)
  588.  
  589. //////////////////////////////////////////////////////////////////////
  590. // terrain definitions
  591. HeightMapSmoothness                    0)
  592. #define        (kMinIntElevation,            -8)
  593. #define        (kMaxIntElevation,            8)
  594. #define        (kElevationScale,                0.5)
  595. #define        (kPercentLand,                Between(.72, .72))
  596. #define        (kWaterBorder,                10)
  597. #define        (kHeightMapChaos,                Between(15, 15))
  598.                                             
  599. #define        (kMinimumStartPositionToMapEdge        1)
  600. #define        (kOuterPushFromMapCenter        28)
  601. #define        (kInnerPushFromMapCenter         0)
  602.  
  603. //////////////////////////////////////////////////////////////////////
  604. // player definitions
  605. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  606. #define        (kPlayerInnerRadius,            0.7)
  607. #define        (kPlayerOuterRadius,            0.85)
  608. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  609. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  610. #define        (kPlayerLandChaos,            0.8)
  611. #define        (kPlayerLandClumps,            1)
  612. #define        (kPlayerFlatChaos,            0.8)
  613. #define        (kPlayerFlatClumps,            2)
  614. #define        (kPlayerTreePercentage,            0.05)
  615.  
  616.  
  617. //////////////////////////////////////////////////////////////////////
  618. // inner neutral definitions
  619. #define        (kNeutralInnerRadius,            0.05)
  620. #define        (kNeutralOuterRadius,            0.55)
  621. #define        (kNeutralOptimalFactor,            0.7)
  622. #define        (kNumInnerNeutrals,            Between(25, 25))
  623. #define        (kInnerNeutralPercentLand,        0.33)
  624. #define        (kInnerNeutralPercentFlat,        0.5)
  625. #define        (kInnerNeutralTreePercentage,          0.1)
  626. #define        (kInnerNeutralLandChaos,        0.9)
  627. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  628. #define        (kInnerNeutralFlatChaos,        0.8)
  629. #define        (kInnerNeutralFlatClumps,        1)
  630.  
  631.  
  632. //////////////////////////////////////////////////////////////////////
  633. // outer neutral definitions
  634. #define        (kNumOuterNeutrals,            15)
  635. #define        (kOuterNeutralPercentLand,        0.35)
  636. #define        (kOuterNeutralPercentFlat,        0.35)
  637. #define        (kOuterNeutralTreePercentage,          0.1)
  638. #define        (kOuterNeutralLandChaos,        0.8)
  639. #define        (kOuterNeutralLandClumps,        2)
  640. #define        (kOuterNeutralFlatChaos,        0.8)
  641. #define        (kOuterNeutralFlatClumps,        1)
  642.  
  643.  
  644. //////////////////////////////////////////////////////////////////////
  645. // resource definitions
  646. #define        (kMaxResourceElevation,            2)
  647. #define        (kResourceToEdgeDistance,        1)
  648. #define        (kResourceToWaterDistance,        1)
  649.  
  650. #define        (kAnimalPerPlayer,            0)
  651. #define        (kAnimalPerNeutral,            0)
  652.  
  653. #if (IsPaleoEpoch) 
  654.   #define  (kBerryPerPlayer,    2)
  655. #else
  656.   #define  (kBerryPerPlayer,    1)
  657. #endif
  658.  
  659. #define        (kBerryPerNeutral,                0)
  660.  
  661. #define        (kFishPerPlayer,                5)
  662. #define        (kFishPerNeutral,                60)
  663.  
  664. #define        (kGoldPerPlayer,                1)
  665. #define        (kGoldPerNeutral,                7)
  666.  
  667. #define        (kOilPerPlayer,                    0)
  668. #define        (kOilPerNeutral,                0)
  669.  
  670. #define        (kSteelPerPlayer,                1)
  671. #define        (kSteelPerNeutral,                7)
  672.  
  673. #define        (kStonePerPlayer,                1)
  674. #define        (kStonePerNeutral,                7)
  675.  
  676. #define        (kTreePerPlayer,                between(2,3))
  677. #define        (kTreePerNeutral,                0)
  678.  
  679.  
  680. //////////////////////////////////////////////////////////////////////
  681. // forest definitions
  682. #define        (kForestFreeRadius,            7.0)
  683. #define        (kForestsPerPlayer,            1)
  684. #define        (kForestChaosLevel,            0.1)
  685. #define        (kMaxClumpsPerForest,              2)
  686. #elif Is8Players
  687.  
  688. //////////////////////////////////////////////////////////////////////
  689. // 8 PLAYERS...
  690. //////////////////////////////////////////////////////////////////////
  691.  
  692. PlaceResourceInRing (Gold, 26, 27)
  693. PlaceResourceInRing (Iron, 26, 27)
  694.  
  695. //////////////////////////////////////////////////////////////////////
  696. // terrain definitions
  697. HeightMapSmoothness                    0)
  698. #define        (kMinIntElevation,            -8)
  699. #define        (kMaxIntElevation,            8)
  700. #define        (kElevationScale,                0.5)
  701. #define        (kPercentLand,                Between(.72, .72))
  702. #define        (kWaterBorder,                10)
  703. #define        (kHeightMapChaos,                Between(15, 15))
  704.                                             
  705. #define        (kMinimumStartPositionToMapEdge        1)
  706. #define        (kOuterPushFromMapCenter        28)
  707. #define        (kInnerPushFromMapCenter         0)
  708.  
  709. //////////////////////////////////////////////////////////////////////
  710. // player definitions
  711. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  712. #define        (kPlayerInnerRadius,            0.7)
  713. #define        (kPlayerOuterRadius,            0.85)
  714. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  715. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  716. #define        (kPlayerLandChaos,            0.8)
  717. #define        (kPlayerLandClumps,            1)
  718. #define        (kPlayerFlatChaos,            0.8)
  719. #define        (kPlayerFlatClumps,            2)
  720. #define        (kPlayerTreePercentage,            0.05)
  721.  
  722.  
  723. //////////////////////////////////////////////////////////////////////
  724. // inner neutral definitions
  725. #define        (kNeutralInnerRadius,            0.05)
  726. #define        (kNeutralOuterRadius,            0.55)
  727. #define        (kNeutralOptimalFactor,            0.7)
  728. #define        (kNumInnerNeutrals,            Between(25, 25))
  729. #define        (kInnerNeutralPercentLand,        0.33)
  730. #define        (kInnerNeutralPercentFlat,        0.5)
  731. #define        (kInnerNeutralTreePercentage,          0.1)
  732. #define        (kInnerNeutralLandChaos,        0.9)
  733. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  734. #define        (kInnerNeutralFlatChaos,        0.8)
  735. #define        (kInnerNeutralFlatClumps,        1)
  736.  
  737.  
  738. //////////////////////////////////////////////////////////////////////
  739. // outer neutral definitions
  740. #define        (kNumOuterNeutrals,            15)
  741. #define        (kOuterNeutralPercentLand,        0.35)
  742. #define        (kOuterNeutralPercentFlat,        0.35)
  743. #define        (kOuterNeutralTreePercentage,          0.1)
  744. #define        (kOuterNeutralLandChaos,        0.8)
  745. #define        (kOuterNeutralLandClumps,        2)
  746. #define        (kOuterNeutralFlatChaos,        0.8)
  747. #define        (kOuterNeutralFlatClumps,        1)
  748.  
  749.  
  750. //////////////////////////////////////////////////////////////////////
  751. // resource definitions
  752. #define        (kMaxResourceElevation,            2)
  753. #define        (kResourceToEdgeDistance,        1)
  754. #define        (kResourceToWaterDistance,        1)
  755.  
  756. #define        (kAnimalPerPlayer,            0)
  757. #define        (kAnimalPerNeutral,            0)
  758.  
  759. #if (IsPaleoEpoch) 
  760.   #define  (kBerryPerPlayer,    2)
  761. #else
  762.   #define  (kBerryPerPlayer,    1)
  763. #endif
  764.  
  765. #define        (kBerryPerNeutral,                0)
  766.  
  767. #define        (kFishPerPlayer,                5)
  768. #define        (kFishPerNeutral,                60)
  769.  
  770. #define        (kGoldPerPlayer,                1)
  771. #define        (kGoldPerNeutral,                7)
  772.  
  773. #define        (kOilPerPlayer,                    0)
  774. #define        (kOilPerNeutral,                0)
  775.  
  776. #define        (kSteelPerPlayer,                1)
  777. #define        (kSteelPerNeutral,                7)
  778.  
  779. #define        (kStonePerPlayer,                1)
  780. #define        (kStonePerNeutral,                8)
  781.  
  782. #define        (kTreePerPlayer,                between(2,3))
  783. #define        (kTreePerNeutral,                0)
  784.  
  785.  
  786. //////////////////////////////////////////////////////////////////////
  787. // forest definitions
  788. #define        (kForestFreeRadius,            7.0)
  789. #define        (kForestsPerPlayer,            1)
  790. #define        (kForestChaosLevel,            0.1)
  791. #define        (kMaxClumpsPerForest,              2)
  792.  
  793. #elif Is9Players
  794. //////////////////////////////////////////////////////////////////////
  795. // 9 PLAYERS...
  796. //////////////////////////////////////////////////////////////////////
  797.  
  798. //////////////////////////////////////////////////////////////////////
  799. // terrain definitions
  800. #define        (kMinIntElevation,            -10)
  801. #define        (kMaxIntElevation,            10)
  802. #define        (kElevationScale,                0.99)
  803. #define        (kPercentLand,                Between(.84, .84))
  804. #define        (kWaterBorder,                0)
  805. #define        (kHeightMapChaos,                Between(8, 20))
  806.  
  807. #define        (kMinimumStartPositionToMapEdge    4)
  808. #define        (kOuterPushFromMapCenter        28)
  809. #define        (kInnerPushFromMapCenter         0)                                            
  810. //////////////////////////////////////////////////////////////////////
  811. // player definitions
  812. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  813. #define        (kPlayerInnerRadius,            0.7)
  814. #define        (kPlayerOuterRadius,            0.99)
  815. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  816. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  817. #define        (kPlayerLandChaos,            0.8)
  818. #define        (kPlayerLandClumps,            1)
  819. #define        (kPlayerFlatChaos,            0.8)
  820. #define        (kPlayerFlatClumps,            2)
  821. #define        (kPlayerTreePercentage,            0.1)
  822.  
  823.  
  824. //////////////////////////////////////////////////////////////////////
  825. // inner neutral definitions
  826. #define        (kNeutralInnerRadius,            0.45)
  827. #define        (kNeutralOuterRadius,            0.45)
  828. #define        (kNeutralOptimalFactor,            0.7)
  829. #define        (kNumInnerNeutrals,            Between(3, 3))
  830. #define        (kInnerNeutralPercentLand,        0.1)
  831. #define        (kInnerNeutralPercentFlat,        0.8)
  832. #define        (kInnerNeutralTreePercentage,          0.2)
  833. #define        (kInnerNeutralLandChaos,        0.9)
  834. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  835. #define        (kInnerNeutralFlatChaos,        0.8)
  836. #define        (kInnerNeutralFlatClumps,        1)
  837.  
  838.  
  839. //////////////////////////////////////////////////////////////////////
  840. // outer neutral definitions
  841. #define        (kNumOuterNeutrals,            22)
  842. #define        (kOuterNeutralPercentLand,        0.45)
  843. #define        (kOuterNeutralPercentFlat,        0.8)
  844. #define        (kOuterNeutralTreePercentage,          0.2)
  845. #define        (kOuterNeutralLandChaos,        0.8)
  846. #define        (kOuterNeutralLandClumps,        2)
  847. #define        (kOuterNeutralFlatChaos,        0.8)
  848. #define        (kOuterNeutralFlatClumps,        1)
  849.  
  850.  
  851. //////////////////////////////////////////////////////////////////////
  852. // resource definitions
  853. #define        (kMaxResourceElevation,            3)
  854. #define        (kResourceToEdgeDistance,        1)
  855. #define        (kResourceToWaterDistance,        1)
  856.  
  857. #define        (kAnimalPerPlayer,            0)
  858. #define        (kAnimalPerNeutral,            0)
  859.  
  860. #define        (kBerryPerPlayer,                1)
  861. #define        (kBerryPerNeutral,            0)
  862.  
  863. #define        (kFishPerPlayer,                0)
  864. #define        (kFishPerNeutral,                45)
  865.  
  866. #define        (kGoldPerPlayer,                2)
  867. #define        (kGoldPerNeutral,                0)
  868.  
  869. #define        (kOilPerPlayer,                0)
  870. #define        (kOilPerNeutral,                0)
  871.  
  872. #define        (kSteelPerPlayer,                2)
  873. #define        (kSteelPerNeutral,            0)
  874.  
  875. #define        (kStonePerPlayer,                1)
  876. #define        (kStonePerNeutral,            5)
  877.  
  878. #define        (kTreePerPlayer,                between(2,3))
  879. #define        (kTreePerNeutral,                0)
  880.  
  881.  
  882. //////////////////////////////////////////////////////////////////////
  883. // forest definitions
  884. #define        (kForestFreeRadius,            8.0)
  885. #define        (kForestsPerPlayer,            1)
  886. #define        (kForestChaosLevel,            0.9)
  887. #define        (kMaxClumpsPerForest,              2)
  888.  
  889.  
  890. #elif Is10Players
  891. //////////////////////////////////////////////////////////////////////
  892. // 10 PLAYERS...
  893. //////////////////////////////////////////////////////////////////////
  894.  
  895. //////////////////////////////////////////////////////////////////////
  896. // terrain definitions
  897. #define        (kMinIntElevation,            -10)
  898. #define        (kMaxIntElevation,            10)
  899. #define        (kElevationScale,                0.99)
  900. #define        (kPercentLand,                Between(.84, .84))
  901. #define        (kWaterBorder,                0)
  902. #define        (kHeightMapChaos,                Between(8, 20))
  903.  
  904. #define        (kMinimumStartPositionToMapEdge    4)
  905. #define        (kOuterPushFromMapCenter        28)
  906. #define        (kInnerPushFromMapCenter         0)                                            
  907. //////////////////////////////////////////////////////////////////////
  908. // player definitions
  909. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  910. #define        (kPlayerInnerRadius,            0.7)
  911. #define        (kPlayerOuterRadius,            0.99)
  912. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  913. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  914. #define        (kPlayerLandChaos,            0.8)
  915. #define        (kPlayerLandClumps,            1)
  916. #define        (kPlayerFlatChaos,            0.8)
  917. #define        (kPlayerFlatClumps,            2)
  918. #define        (kPlayerTreePercentage,            0.1)
  919.  
  920.  
  921. //////////////////////////////////////////////////////////////////////
  922. // inner neutral definitions
  923. #define        (kNeutralInnerRadius,            0.45)
  924. #define        (kNeutralOuterRadius,            0.45)
  925. #define        (kNeutralOptimalFactor,            0.7)
  926. #define        (kNumInnerNeutrals,            Between(3, 3))
  927. #define        (kInnerNeutralPercentLand,        0.1)
  928. #define        (kInnerNeutralPercentFlat,        0.8)
  929. #define        (kInnerNeutralTreePercentage,          0.2)
  930. #define        (kInnerNeutralLandChaos,        0.9)
  931. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  932. #define        (kInnerNeutralFlatChaos,        0.8)
  933. #define        (kInnerNeutralFlatClumps,        1)
  934.  
  935.  
  936. //////////////////////////////////////////////////////////////////////
  937. // outer neutral definitions
  938. #define        (kNumOuterNeutrals,            22)
  939. #define        (kOuterNeutralPercentLand,        0.45)
  940. #define        (kOuterNeutralPercentFlat,        0.8)
  941. #define        (kOuterNeutralTreePercentage,          0.2)
  942. #define        (kOuterNeutralLandChaos,        0.8)
  943. #define        (kOuterNeutralLandClumps,        2)
  944. #define        (kOuterNeutralFlatChaos,        0.8)
  945. #define        (kOuterNeutralFlatClumps,        1)
  946.  
  947.  
  948. //////////////////////////////////////////////////////////////////////
  949. // resource definitions
  950. #define        (kMaxResourceElevation,            3)
  951. #define        (kResourceToEdgeDistance,        1)
  952. #define        (kResourceToWaterDistance,        1)
  953.  
  954. #define        (kAnimalPerPlayer,            0)
  955. #define        (kAnimalPerNeutral,            0)
  956.  
  957. #define        (kBerryPerPlayer,                1)
  958. #define        (kBerryPerNeutral,            0)
  959.  
  960. #define        (kFishPerPlayer,                0)
  961. #define        (kFishPerNeutral,                45)
  962.  
  963. #define        (kGoldPerPlayer,                2)
  964. #define        (kGoldPerNeutral,                0)
  965.  
  966. #define        (kOilPerPlayer,                0)
  967. #define        (kOilPerNeutral,                0)
  968.  
  969. #define        (kSteelPerPlayer,                2)
  970. #define        (kSteelPerNeutral,            0)
  971.  
  972. #define        (kStonePerPlayer,                1)
  973. #define        (kStonePerNeutral,            5)
  974.  
  975. #define        (kTreePerPlayer,                between(2,3))
  976. #define        (kTreePerNeutral,                0)
  977.  
  978.  
  979. //////////////////////////////////////////////////////////////////////
  980. // forest definitions
  981. #define        (kForestFreeRadius,            8.0)
  982. #define        (kForestsPerPlayer,            1)
  983. #define        (kForestChaosLevel,            0.9)
  984. #define        (kMaxClumpsPerForest,              2)
  985.  
  986.  
  987. #elif Is11Players
  988. //////////////////////////////////////////////////////////////////////
  989. // 11 PLAYERS...
  990. //////////////////////////////////////////////////////////////////////
  991.  
  992. //////////////////////////////////////////////////////////////////////
  993. // terrain definitions
  994. #define        (kMinIntElevation,            -10)
  995. #define        (kMaxIntElevation,            10)
  996. #define        (kElevationScale,                0.99)
  997. #define        (kPercentLand,                Between(.84, .84))
  998. #define        (kWaterBorder,                0)
  999. #define        (kHeightMapChaos,                Between(8, 20))
  1000.  
  1001. #define        (kMinimumStartPositionToMapEdge    4)
  1002. #define        (kOuterPushFromMapCenter        28)
  1003. #define        (kInnerPushFromMapCenter         0)                                            
  1004. //////////////////////////////////////////////////////////////////////
  1005. // player definitions
  1006. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1007. #define        (kPlayerInnerRadius,            0.7)
  1008. #define        (kPlayerOuterRadius,            0.99)
  1009. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1010. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  1011. #define        (kPlayerLandChaos,            0.8)
  1012. #define        (kPlayerLandClumps,            1)
  1013. #define        (kPlayerFlatChaos,            0.8)
  1014. #define        (kPlayerFlatClumps,            2)
  1015. #define        (kPlayerTreePercentage,            0.1)
  1016.  
  1017.  
  1018. //////////////////////////////////////////////////////////////////////
  1019. // inner neutral definitions
  1020. #define        (kNeutralInnerRadius,            0.45)
  1021. #define        (kNeutralOuterRadius,            0.45)
  1022. #define        (kNeutralOptimalFactor,            0.7)
  1023. #define        (kNumInnerNeutrals,            Between(3, 3))
  1024. #define        (kInnerNeutralPercentLand,        0.1)
  1025. #define        (kInnerNeutralPercentFlat,        0.8)
  1026. #define        (kInnerNeutralTreePercentage,          0.2)
  1027. #define        (kInnerNeutralLandChaos,        0.9)
  1028. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1029. #define        (kInnerNeutralFlatChaos,        0.8)
  1030. #define        (kInnerNeutralFlatClumps,        1)
  1031.  
  1032.  
  1033. //////////////////////////////////////////////////////////////////////
  1034. // outer neutral definitions
  1035. #define        (kNumOuterNeutrals,            22)
  1036. #define        (kOuterNeutralPercentLand,        0.45)
  1037. #define        (kOuterNeutralPercentFlat,        0.8)
  1038. #define        (kOuterNeutralTreePercentage,          0.2)
  1039. #define        (kOuterNeutralLandChaos,        0.8)
  1040. #define        (kOuterNeutralLandClumps,        2)
  1041. #define        (kOuterNeutralFlatChaos,        0.8)
  1042. #define        (kOuterNeutralFlatClumps,        1)
  1043.  
  1044.  
  1045. //////////////////////////////////////////////////////////////////////
  1046. // resource definitions
  1047. #define        (kMaxResourceElevation,            3)
  1048. #define        (kResourceToEdgeDistance,        1)
  1049. #define        (kResourceToWaterDistance,        1)
  1050.  
  1051. #define        (kAnimalPerPlayer,            0)
  1052. #define        (kAnimalPerNeutral,            0)
  1053.  
  1054. #define        (kBerryPerPlayer,                1)
  1055. #define        (kBerryPerNeutral,            0)
  1056.  
  1057. #define        (kFishPerPlayer,                0)
  1058. #define        (kFishPerNeutral,                45)
  1059.  
  1060. #define        (kGoldPerPlayer,                2)
  1061. #define        (kGoldPerNeutral,                0)
  1062.  
  1063. #define        (kOilPerPlayer,                0)
  1064. #define        (kOilPerNeutral,                0)
  1065.  
  1066. #define        (kSteelPerPlayer,                2)
  1067. #define        (kSteelPerNeutral,            0)
  1068.  
  1069. #define        (kStonePerPlayer,                1)
  1070. #define        (kStonePerNeutral,            5)
  1071.  
  1072. #define        (kTreePerPlayer,                between(2,3))
  1073. #define        (kTreePerNeutral,                0)
  1074.  
  1075.  
  1076. //////////////////////////////////////////////////////////////////////
  1077. // forest definitions
  1078. #define        (kForestFreeRadius,            8.0)
  1079. #define        (kForestsPerPlayer,            1)
  1080. #define        (kForestChaosLevel,            0.9)
  1081. #define        (kMaxClumpsPerForest,              2)
  1082.  
  1083.  
  1084. #elif Is12Players
  1085. //////////////////////////////////////////////////////////////////////
  1086. // 12 PLAYERS...
  1087. //////////////////////////////////////////////////////////////////////
  1088.  
  1089. //////////////////////////////////////////////////////////////////////
  1090. // terrain definitions
  1091. #define        (kMinIntElevation,            -10)
  1092. #define        (kMaxIntElevation,            10)
  1093. #define        (kElevationScale,                0.99)
  1094. #define        (kPercentLand,                Between(.84, .84))
  1095. #define        (kWaterBorder,                0)
  1096. #define        (kHeightMapChaos,                Between(8, 20))
  1097.  
  1098. #define        (kMinimumStartPositionToMapEdge    4)
  1099. #define        (kOuterPushFromMapCenter        28)
  1100. #define        (kInnerPushFromMapCenter         0)                                            
  1101. //////////////////////////////////////////////////////////////////////
  1102. // player definitions
  1103. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1104. #define        (kPlayerInnerRadius,            0.7)
  1105. #define        (kPlayerOuterRadius,            0.99)
  1106. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1107. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  1108. #define        (kPlayerLandChaos,            0.8)
  1109. #define        (kPlayerLandClumps,            1)
  1110. #define        (kPlayerFlatChaos,            0.8)
  1111. #define        (kPlayerFlatClumps,            2)
  1112. #define        (kPlayerTreePercentage,            0.1)
  1113.  
  1114.  
  1115. //////////////////////////////////////////////////////////////////////
  1116. // inner neutral definitions
  1117. #define        (kNeutralInnerRadius,            0.45)
  1118. #define        (kNeutralOuterRadius,            0.45)
  1119. #define        (kNeutralOptimalFactor,            0.7)
  1120. #define        (kNumInnerNeutrals,            Between(3, 3))
  1121. #define        (kInnerNeutralPercentLand,        0.1)
  1122. #define        (kInnerNeutralPercentFlat,        0.8)
  1123. #define        (kInnerNeutralTreePercentage,          0.2)
  1124. #define        (kInnerNeutralLandChaos,        0.9)
  1125. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1126. #define        (kInnerNeutralFlatChaos,        0.8)
  1127. #define        (kInnerNeutralFlatClumps,        1)
  1128.  
  1129.  
  1130. //////////////////////////////////////////////////////////////////////
  1131. // outer neutral definitions
  1132. #define        (kNumOuterNeutrals,            22)
  1133. #define        (kOuterNeutralPercentLand,        0.45)
  1134. #define        (kOuterNeutralPercentFlat,        0.8)
  1135. #define        (kOuterNeutralTreePercentage,          0.2)
  1136. #define        (kOuterNeutralLandChaos,        0.8)
  1137. #define        (kOuterNeutralLandClumps,        2)
  1138. #define        (kOuterNeutralFlatChaos,        0.8)
  1139. #define        (kOuterNeutralFlatClumps,        1)
  1140.  
  1141.  
  1142. //////////////////////////////////////////////////////////////////////
  1143. // resource definitions
  1144. #define        (kMaxResourceElevation,            3)
  1145. #define        (kResourceToEdgeDistance,        1)
  1146. #define        (kResourceToWaterDistance,        1)
  1147.  
  1148. #define        (kAnimalPerPlayer,            0)
  1149. #define        (kAnimalPerNeutral,            0)
  1150.  
  1151. #define        (kBerryPerPlayer,                1)
  1152. #define        (kBerryPerNeutral,            0)
  1153.  
  1154. #define        (kFishPerPlayer,                0)
  1155. #define        (kFishPerNeutral,                45)
  1156.  
  1157. #define        (kGoldPerPlayer,                2)
  1158. #define        (kGoldPerNeutral,                0)
  1159.  
  1160. #define        (kOilPerPlayer,                0)
  1161. #define        (kOilPerNeutral,                0)
  1162.  
  1163. #define        (kSteelPerPlayer,                2)
  1164. #define        (kSteelPerNeutral,            0)
  1165.  
  1166. #define        (kStonePerPlayer,                1)
  1167. #define        (kStonePerNeutral,            5)
  1168.  
  1169. #define        (kTreePerPlayer,                between(2,3))
  1170. #define        (kTreePerNeutral,                0)
  1171.  
  1172.  
  1173. //////////////////////////////////////////////////////////////////////
  1174. // forest definitions
  1175. #define        (kForestFreeRadius,            8.0)
  1176. #define        (kForestsPerPlayer,            1)
  1177. #define        (kForestChaosLevel,            0.9)
  1178. #define        (kMaxClumpsPerForest,              2)
  1179.  
  1180.  
  1181. #elif Is13Players
  1182. //////////////////////////////////////////////////////////////////////
  1183. // 13 PLAYERS...
  1184. //////////////////////////////////////////////////////////////////////
  1185.  
  1186. //////////////////////////////////////////////////////////////////////
  1187. // terrain definitions
  1188. #define        (kMinIntElevation,            -10)
  1189. #define        (kMaxIntElevation,            10)
  1190. #define        (kElevationScale,                0.99)
  1191. #define        (kPercentLand,                Between(.84, .84))
  1192. #define        (kWaterBorder,                0)
  1193. #define        (kHeightMapChaos,                Between(8, 20))
  1194.  
  1195. #define        (kMinimumStartPositionToMapEdge    4)
  1196. #define        (kOuterPushFromMapCenter        28)
  1197. #define        (kInnerPushFromMapCenter         0)                                            
  1198. //////////////////////////////////////////////////////////////////////
  1199. // player definitions
  1200. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1201. #define        (kPlayerInnerRadius,            0.7)
  1202. #define        (kPlayerOuterRadius,            0.99)
  1203. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1204. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  1205. #define        (kPlayerLandChaos,            0.8)
  1206. #define        (kPlayerLandClumps,            1)
  1207. #define        (kPlayerFlatChaos,            0.8)
  1208. #define        (kPlayerFlatClumps,            2)
  1209. #define        (kPlayerTreePercentage,            0.1)
  1210.  
  1211.  
  1212. //////////////////////////////////////////////////////////////////////
  1213. // inner neutral definitions
  1214. #define        (kNeutralInnerRadius,            0.45)
  1215. #define        (kNeutralOuterRadius,            0.45)
  1216. #define        (kNeutralOptimalFactor,            0.7)
  1217. #define        (kNumInnerNeutrals,            Between(3, 3))
  1218. #define        (kInnerNeutralPercentLand,        0.1)
  1219. #define        (kInnerNeutralPercentFlat,        0.8)
  1220. #define        (kInnerNeutralTreePercentage,          0.2)
  1221. #define        (kInnerNeutralLandChaos,        0.9)
  1222. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1223. #define        (kInnerNeutralFlatChaos,        0.8)
  1224. #define        (kInnerNeutralFlatClumps,        1)
  1225.  
  1226.  
  1227. //////////////////////////////////////////////////////////////////////
  1228. // outer neutral definitions
  1229. #define        (kNumOuterNeutrals,            22)
  1230. #define        (kOuterNeutralPercentLand,        0.45)
  1231. #define        (kOuterNeutralPercentFlat,        0.8)
  1232. #define        (kOuterNeutralTreePercentage,          0.2)
  1233. #define        (kOuterNeutralLandChaos,        0.8)
  1234. #define        (kOuterNeutralLandClumps,        2)
  1235. #define        (kOuterNeutralFlatChaos,        0.8)
  1236. #define        (kOuterNeutralFlatClumps,        1)
  1237.  
  1238.  
  1239. //////////////////////////////////////////////////////////////////////
  1240. // resource definitions
  1241. #define        (kMaxResourceElevation,            3)
  1242. #define        (kResourceToEdgeDistance,        1)
  1243. #define        (kResourceToWaterDistance,        1)
  1244.  
  1245. #define        (kAnimalPerPlayer,            0)
  1246. #define        (kAnimalPerNeutral,            0)
  1247.  
  1248. #define        (kBerryPerPlayer,                1)
  1249. #define        (kBerryPerNeutral,            0)
  1250.  
  1251. #define        (kFishPerPlayer,                0)
  1252. #define        (kFishPerNeutral,                45)
  1253.  
  1254. #define        (kGoldPerPlayer,                2)
  1255. #define        (kGoldPerNeutral,                0)
  1256.  
  1257. #define        (kOilPerPlayer,                0)
  1258. #define        (kOilPerNeutral,                0)
  1259.  
  1260. #define        (kSteelPerPlayer,                2)
  1261. #define        (kSteelPerNeutral,            0)
  1262.  
  1263. #define        (kStonePerPlayer,                1)
  1264. #define        (kStonePerNeutral,            5)
  1265.  
  1266. #define        (kTreePerPlayer,                between(2,3))
  1267. #define        (kTreePerNeutral,                0)
  1268.  
  1269.  
  1270. //////////////////////////////////////////////////////////////////////
  1271. // forest definitions
  1272. #define        (kForestFreeRadius,            8.0)
  1273. #define        (kForestsPerPlayer,            1)
  1274. #define        (kForestChaosLevel,            0.9)
  1275. #define        (kMaxClumpsPerForest,              2)
  1276.  
  1277.  
  1278. #elif Is14Players
  1279. //////////////////////////////////////////////////////////////////////
  1280. // 14 PLAYERS...
  1281. //////////////////////////////////////////////////////////////////////
  1282.  
  1283. //////////////////////////////////////////////////////////////////////
  1284. // terrain definitions
  1285. #define        (kMinIntElevation,            -10)
  1286. #define        (kMaxIntElevation,            10)
  1287. #define        (kElevationScale,                0.99)
  1288. #define        (kPercentLand,                Between(.84, .84))
  1289. #define        (kWaterBorder,                0)
  1290. #define        (kHeightMapChaos,                Between(8, 20))
  1291.  
  1292. #define        (kMinimumStartPositionToMapEdge    4)
  1293. #define        (kOuterPushFromMapCenter        28)
  1294. #define        (kInnerPushFromMapCenter         0)                                            
  1295. //////////////////////////////////////////////////////////////////////
  1296. // player definitions
  1297. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1298. #define        (kPlayerInnerRadius,            0.7)
  1299. #define        (kPlayerOuterRadius,            0.99)
  1300. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1301. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  1302. #define        (kPlayerLandChaos,            0.8)
  1303. #define        (kPlayerLandClumps,            1)
  1304. #define        (kPlayerFlatChaos,            0.8)
  1305. #define        (kPlayerFlatClumps,            2)
  1306. #define        (kPlayerTreePercentage,            0.1)
  1307.  
  1308.  
  1309. //////////////////////////////////////////////////////////////////////
  1310. // inner neutral definitions
  1311. #define        (kNeutralInnerRadius,            0.45)
  1312. #define        (kNeutralOuterRadius,            0.45)
  1313. #define        (kNeutralOptimalFactor,            0.7)
  1314. #define        (kNumInnerNeutrals,            Between(3, 3))
  1315. #define        (kInnerNeutralPercentLand,        0.1)
  1316. #define        (kInnerNeutralPercentFlat,        0.8)
  1317. #define        (kInnerNeutralTreePercentage,          0.2)
  1318. #define        (kInnerNeutralLandChaos,        0.9)
  1319. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1320. #define        (kInnerNeutralFlatChaos,        0.8)
  1321. #define        (kInnerNeutralFlatClumps,        1)
  1322.  
  1323.  
  1324. //////////////////////////////////////////////////////////////////////
  1325. // outer neutral definitions
  1326. #define        (kNumOuterNeutrals,            22)
  1327. #define        (kOuterNeutralPercentLand,        0.45)
  1328. #define        (kOuterNeutralPercentFlat,        0.8)
  1329. #define        (kOuterNeutralTreePercentage,          0.2)
  1330. #define        (kOuterNeutralLandChaos,        0.8)
  1331. #define        (kOuterNeutralLandClumps,        2)
  1332. #define        (kOuterNeutralFlatChaos,        0.8)
  1333. #define        (kOuterNeutralFlatClumps,        1)
  1334.  
  1335.  
  1336. //////////////////////////////////////////////////////////////////////
  1337. // resource definitions
  1338. #define        (kMaxResourceElevation,            3)
  1339. #define        (kResourceToEdgeDistance,        1)
  1340. #define        (kResourceToWaterDistance,        1)
  1341.  
  1342. #define        (kAnimalPerPlayer,            0)
  1343. #define        (kAnimalPerNeutral,            0)
  1344.  
  1345. #define        (kBerryPerPlayer,                1)
  1346. #define        (kBerryPerNeutral,            0)
  1347.  
  1348. #define        (kFishPerPlayer,                0)
  1349. #define        (kFishPerNeutral,                45)
  1350.  
  1351. #define        (kGoldPerPlayer,                2)
  1352. #define        (kGoldPerNeutral,                0)
  1353.  
  1354. #define        (kOilPerPlayer,                0)
  1355. #define        (kOilPerNeutral,                0)
  1356.  
  1357. #define        (kSteelPerPlayer,                2)
  1358. #define        (kSteelPerNeutral,            0)
  1359.  
  1360. #define        (kStonePerPlayer,                1)
  1361. #define        (kStonePerNeutral,            5)
  1362.  
  1363. #define        (kTreePerPlayer,                between(2,3))
  1364. #define        (kTreePerNeutral,                0)
  1365.  
  1366.  
  1367. //////////////////////////////////////////////////////////////////////
  1368. // forest definitions
  1369. #define        (kForestFreeRadius,            8.0)
  1370. #define        (kForestsPerPlayer,            1)
  1371. #define        (kForestChaosLevel,            0.9)
  1372. #define        (kMaxClumpsPerForest,              2)
  1373.  
  1374.  
  1375. #elif Is15Players
  1376. //////////////////////////////////////////////////////////////////////
  1377. // 15 PLAYERS...
  1378. //////////////////////////////////////////////////////////////////////
  1379.  
  1380. //////////////////////////////////////////////////////////////////////
  1381. // terrain definitions
  1382. #define        (kMinIntElevation,            -10)
  1383. #define        (kMaxIntElevation,            10)
  1384. #define        (kElevationScale,                0.99)
  1385. #define        (kPercentLand,                Between(.84, .84))
  1386. #define        (kWaterBorder,                0)
  1387. #define        (kHeightMapChaos,                Between(8, 20))
  1388.  
  1389. #define        (kMinimumStartPositionToMapEdge    4)
  1390. #define        (kOuterPushFromMapCenter        28)
  1391. #define        (kInnerPushFromMapCenter         0)                                            
  1392. //////////////////////////////////////////////////////////////////////
  1393. // player definitions
  1394. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1395. #define        (kPlayerInnerRadius,            0.7)
  1396. #define        (kPlayerOuterRadius,            0.99)
  1397. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1398. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  1399. #define        (kPlayerLandChaos,            0.8)
  1400. #define        (kPlayerLandClumps,            1)
  1401. #define        (kPlayerFlatChaos,            0.8)
  1402. #define        (kPlayerFlatClumps,            2)
  1403. #define        (kPlayerTreePercentage,            0.1)
  1404.  
  1405.  
  1406. //////////////////////////////////////////////////////////////////////
  1407. // inner neutral definitions
  1408. #define        (kNeutralInnerRadius,            0.45)
  1409. #define        (kNeutralOuterRadius,            0.45)
  1410. #define        (kNeutralOptimalFactor,            0.7)
  1411. #define        (kNumInnerNeutrals,            Between(3, 3))
  1412. #define        (kInnerNeutralPercentLand,        0.1)
  1413. #define        (kInnerNeutralPercentFlat,        0.8)
  1414. #define        (kInnerNeutralTreePercentage,          0.2)
  1415. #define        (kInnerNeutralLandChaos,        0.9)
  1416. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1417. #define        (kInnerNeutralFlatChaos,        0.8)
  1418. #define        (kInnerNeutralFlatClumps,        1)
  1419.  
  1420.  
  1421. //////////////////////////////////////////////////////////////////////
  1422. // outer neutral definitions
  1423. #define        (kNumOuterNeutrals,            22)
  1424. #define        (kOuterNeutralPercentLand,        0.45)
  1425. #define        (kOuterNeutralPercentFlat,        0.8)
  1426. #define        (kOuterNeutralTreePercentage,          0.2)
  1427. #define        (kOuterNeutralLandChaos,        0.8)
  1428. #define        (kOuterNeutralLandClumps,        2)
  1429. #define        (kOuterNeutralFlatChaos,        0.8)
  1430. #define        (kOuterNeutralFlatClumps,        1)
  1431.  
  1432.  
  1433. //////////////////////////////////////////////////////////////////////
  1434. // resource definitions
  1435. #define        (kMaxResourceElevation,            3)
  1436. #define        (kResourceToEdgeDistance,        1)
  1437. #define        (kResourceToWaterDistance,        1)
  1438.  
  1439. #define        (kAnimalPerPlayer,            0)
  1440. #define        (kAnimalPerNeutral,            0)
  1441.  
  1442. #define        (kBerryPerPlayer,                1)
  1443. #define        (kBerryPerNeutral,            0)
  1444.  
  1445. #define        (kFishPerPlayer,                0)
  1446. #define        (kFishPerNeutral,                45)
  1447.  
  1448. #define        (kGoldPerPlayer,                2)
  1449. #define        (kGoldPerNeutral,                0)
  1450.  
  1451. #define        (kOilPerPlayer,                0)
  1452. #define        (kOilPerNeutral,                0)
  1453.  
  1454. #define        (kSteelPerPlayer,                2)
  1455. #define        (kSteelPerNeutral,            0)
  1456.  
  1457. #define        (kStonePerPlayer,                1)
  1458. #define        (kStonePerNeutral,            5)
  1459.  
  1460. #define        (kTreePerPlayer,                between(2,3))
  1461. #define        (kTreePerNeutral,                0)
  1462.  
  1463.  
  1464. //////////////////////////////////////////////////////////////////////
  1465. // forest definitions
  1466. #define        (kForestFreeRadius,            8.0)
  1467. #define        (kForestsPerPlayer,            1)
  1468. #define        (kForestChaosLevel,            0.9)
  1469. #define        (kMaxClumpsPerForest,              2)
  1470.  
  1471.  
  1472. #elif Is16Players
  1473. //////////////////////////////////////////////////////////////////////
  1474. // 16 PLAYERS...
  1475. //////////////////////////////////////////////////////////////////////
  1476.  
  1477. //////////////////////////////////////////////////////////////////////
  1478. // terrain definitions
  1479. #define        (kMinIntElevation,            -10)
  1480. #define        (kMaxIntElevation,            10)
  1481. #define        (kElevationScale,                0.99)
  1482. #define        (kPercentLand,                Between(.84, .84))
  1483. #define        (kWaterBorder,                0)
  1484. #define        (kHeightMapChaos,                Between(8, 20))
  1485.  
  1486. #define        (kMinimumStartPositionToMapEdge    4)
  1487. #define        (kOuterPushFromMapCenter        28)
  1488. #define        (kInnerPushFromMapCenter         0)                                            
  1489. //////////////////////////////////////////////////////////////////////
  1490. // player definitions
  1491. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1492. #define        (kPlayerInnerRadius,            0.7)
  1493. #define        (kPlayerOuterRadius,            0.99)
  1494. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1495. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  1496. #define        (kPlayerLandChaos,            0.8)
  1497. #define        (kPlayerLandClumps,            1)
  1498. #define        (kPlayerFlatChaos,            0.8)
  1499. #define        (kPlayerFlatClumps,            2)
  1500. #define        (kPlayerTreePercentage,            0.1)
  1501.  
  1502.  
  1503. //////////////////////////////////////////////////////////////////////
  1504. // inner neutral definitions
  1505. #define        (kNeutralInnerRadius,            0.45)
  1506. #define        (kNeutralOuterRadius,            0.45)
  1507. #define        (kNeutralOptimalFactor,            0.7)
  1508. #define        (kNumInnerNeutrals,            Between(3, 3))
  1509. #define        (kInnerNeutralPercentLand,        0.1)
  1510. #define        (kInnerNeutralPercentFlat,        0.8)
  1511. #define        (kInnerNeutralTreePercentage,          0.2)
  1512. #define        (kInnerNeutralLandChaos,        0.9)
  1513. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1514. #define        (kInnerNeutralFlatChaos,        0.8)
  1515. #define        (kInnerNeutralFlatClumps,        1)
  1516.  
  1517.  
  1518. //////////////////////////////////////////////////////////////////////
  1519. // outer neutral definitions
  1520. #define        (kNumOuterNeutrals,            22)
  1521. #define        (kOuterNeutralPercentLand,        0.45)
  1522. #define        (kOuterNeutralPercentFlat,        0.8)
  1523. #define        (kOuterNeutralTreePercentage,          0.2)
  1524. #define        (kOuterNeutralLandChaos,        0.8)
  1525. #define        (kOuterNeutralLandClumps,        2)
  1526. #define        (kOuterNeutralFlatChaos,        0.8)
  1527. #define        (kOuterNeutralFlatClumps,        1)
  1528.  
  1529.  
  1530. //////////////////////////////////////////////////////////////////////
  1531. // resource definitions
  1532. #define        (kMaxResourceElevation,            3)
  1533. #define        (kResourceToEdgeDistance,        1)
  1534. #define        (kResourceToWaterDistance,        1)
  1535.  
  1536. #define        (kAnimalPerPlayer,            0)
  1537. #define        (kAnimalPerNeutral,            0)
  1538.  
  1539. #define        (kBerryPerPlayer,                1)
  1540. #define        (kBerryPerNeutral,            0)
  1541.  
  1542. #define        (kFishPerPlayer,                0)
  1543. #define        (kFishPerNeutral,                45)
  1544.  
  1545. #define        (kGoldPerPlayer,                2)
  1546. #define        (kGoldPerNeutral,                0)
  1547.  
  1548. #define        (kOilPerPlayer,                0)
  1549. #define        (kOilPerNeutral,                0)
  1550.  
  1551. #define        (kSteelPerPlayer,                2)
  1552. #define        (kSteelPerNeutral,            0)
  1553.  
  1554. #define        (kStonePerPlayer,                1)
  1555. #define        (kStonePerNeutral,            5)
  1556.  
  1557. #define        (kTreePerPlayer,                between(2,3))
  1558. #define        (kTreePerNeutral,                0)
  1559.  
  1560.  
  1561. //////////////////////////////////////////////////////////////////////
  1562. // forest definitions
  1563. #define        (kForestFreeRadius,            8.0)
  1564. #define        (kForestsPerPlayer,            1)
  1565. #define        (kForestChaosLevel,            0.9)
  1566. #define        (kMaxClumpsPerForest,              2)
  1567.  
  1568.  
  1569. //////////////////////////////////////////////////////////////////////
  1570. // End of if...elif... command
  1571. #endif
  1572.  
  1573.  
  1574. #endif        // NOTDEFINED(CONTINENTAL_LARGE_RMV)